/**
 * @content 用于对多点的几何功能组件
 * @author  2019-09-09
 */
import { NativeModules } from 'react-native';

let GP = NativeModules.JSGeoPoints;

import GeometryExp from './GeometryExp.js';
import Dot3D from './Dot3D.js';
import Dots3D from './Dots3D.js';

/**
 * @class GeoPoints
 */
export default class GeoPoints extends GeometryExp {
  constructor() {
    super();
    Object.defineProperty(this, '_MGGeoPointsId', {
      get: function() {
        return this._MGGeometryId;
      },
      set: function(_MGGeoPointsId) {
        this._MGGeometryId = _MGGeoPointsId;
      },
    });
  }

  /**
   * 构造一个新的 GeoPoints 对象
   * @memberOf GeoPoints
   * @return {Promise<GeoPoints>}
   */
  async createObj() {
    try {
      var { GeoPointsId } = await GP.createObj();
      var geoPoints = new GeoPoints();
      geoPoints._MGGeoPointsId = GeoPointsId;
      return geoPoints;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取几何对象的类型
   * @memberOf GeoPoints
   * @return {Promise} 几何对象类型
   */
  async getType() {
    try {
      return await GP.getType(this._MGGeoPointsId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取几何维数
   * @memberOf GeoPoints
   * @return {Promise}几何维数
   */
  async getDimension() {
    try {
      return await GP.getDimension(this._MGGeoPointsId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 计算两个几何对象间的距离
   * @memberOf GeoPoints
   * @param type 距离计算方法
   * @param destGeom 第二个几何对象
   * @return {Promise} 距离长度
   */
  async distance(type, destGeom) {
    try {
      return await GP.distance(
        this._MGGeoPointsId,
        type,
        destGeom._MGGeometryId
      );
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 添加3维点
   * @memberOf GeoPoints
   * @param dot 三维点坐标
   * @return {Promise} 添加成功返回1，失败返回0
   */
  async append(dot3D) {
    try {
      return await GP.append(this._MGGeoPointsId, dot3D._MGDot3DId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 删除指定的某个3维点
   * @memberOf GeoPoints
   * @param index 指定的点序列
   * @return {Promise} 删除成功返回1，失败返回0
   */
  async del(index) {
    try {
      return await GP.del(this._MGGeoPointsId, index);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取指定的3维点
   * @memberOf GeoPoints
   * @param index 指定的点序列
   * @return {Promise<Dot3D>}获取到的三维点坐标
   */
  async get(index) {
    try {
      let { Dot3DId } = await GP.get(this._MGGeoPointsId, index);
      var dot3D = new Dot3D();
      dot3D._MGDot3DId = Dot3DId;
      return dot3D;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取点的总个数
   * @memberOf GeoPoints
   * @return {Promise} 点的总个数
   */
  async getDotNum() {
    try {
      return await GP.getDotNum(this._MGGeoPointsId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 取3维点序列
   * @memberOf GeoPoints
   * @return {Promise<Dots3D>}整个三维点序列
   */
  async getDots() {
    try {
      let { Dots3DId } = await GP.getDots(this._MGGeoPointsId);
      var dots3D = new Dots3D();
      dots3D._MGDots3DId = Dots3DId;
      return dots3D;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置3维点序列
   * @memberOf GeoPoints
   * @param dots 待设置的三维点序列
   * @return {Promise} 设置成功返回1，失败返回0
   */
  async setDots(dots3D) {
    try {
      return await GP.setDots(this._MGGeoPointsId, dots3D._MGDots3DId);
    } catch (e) {
      console.error(e);
    }
  }
}
